\documentclass[a4paper, 11pt]{article}	

%%%% package disponible sur http://code.google.com/p/my-latex-style/ %%%%
\usepackage[algo, math]{standard}

\begin{document}

\newcommand{\res}{\emph{res}\ }
\newcommand{\event}{\emph{event}\ }
\newcommand{\queue}{\emph{queue}\ }
\newcommand{\tab}{\emph{tab}\ }
\newcommand{\reduceI}{\emph{reduce\_init}\ }
\newcommand{\reduceF}{\emph{reduce\_function}\ }
\newcommand{\roots}{\emph{roots}\ }

\begin{algorithm}[H]
	\caption{Main : méthode appelé dans SearchForest2}
	\Donnees{
		\reduceI : l'élément neutre pour l'opération \reduceF\\
	    \roots : les racines des arbres à explorer }
	
	\BlankLine
	\tcp{*** INITIALISATION ***}
	\res $\la$ reduce\_init\;
	\event $\la$ création d'un événement\;
	\tcp{queue de thread ou queue de processus}
	\queue $\la$ création d'une queue\;
	$n \la$ nombre de processeurs disponible\;
	\tab $\la$ tableau de $n$ thread/processus\;
	
	\BlankLine
	\tcp{*** DISTRIBUTION DU TRAVAIL ***}
	\queue reçoit \roots\;
	\tcp{à définir \ldots}
	distribuer du travail aux membres de \tab\;
	
	\BlankLine
	\tcp{*** D\'EMARRAGE DU PARCOURS ***}
	démarrer tous les membres de \tab\;
	
	\BlankLine
	\tcp{*** ATTENTE DE LA FIN DU PARCOURS ***}
	attendre \event\;
	
	\BlankLine
	\tcp{*** ASSEMBLAGE DES RESULTATS ***}
	\PourCh{membre \textbf{de} \tab}{
		\res $\la$ \reduceF (\res, membre.\res)
	}
	
	\BlankLine
	\tcp{*** RETOUR ***}
	\Retour{\res}
\end{algorithm}

\newcommand{\pp}{\emph{post\_process}}
\newcommand{\st}{\emph{statistic}}
\newcommand{\chd}{\emph{children}}

\paragraph{}
L'algorithme ``main'' est une méthode de ``SearchForest2''. 
L'algorithme suivant va posséder un accès priviliégé aux méthodes
et variables d'instances de ``SearchForest2'' : \reduceF et \reduceI
ainsi \pp, \st et \chd.

\newcommand{\eventM}{\emph{eventM}\ }
\newcommand{\runnn}{\emph{runnn}\ }
\newcommand{\liste}{\emph{liste}\ }
\newcommand{\nodes}{\emph{noeuds}\ }
\newcommand{\obj}{\emph{obj}\ }

\begin{algorithm}[H]
	\caption{Multi Thread/Proc : méthode principale des threads / pro\-ces\-sus}
	\Donnees{
	    \queue : une queue commune à tous les threads/procs\\
	    \eventM : un événement commun qui va être utilisé pour indique une
	    terminaison (possible) du parcours\\
	    \liste : la liste des éléments restant à parcourir, c'est une liste propre
	    à chaque thread/pro *** INITIALIS\'E par MAIN??? ***\\
	    \obj : désigne l'instance principale qui a fait appel aux thread/proc}
	
	\BlankLine
	\tcp{*** INITIALISATION ***}
	\runnn $\la$ VRAI\;
	\res $\la$ \reduceI\;
	\tcp{variable utilisée pour se synchroniser de temps en temps}
	$i \la 0$\;
	
	\tcp{*** BOUCLE PRINCIPALE ***}
	\Tq{\runnn}{
		\tcp{** le cas général du parcours, liste non vide **}
		\lSi{non estVide(\liste)} {
			\nodes $\la$ pop(\liste)\;
		}
		\tcp{** le cas où la liste est vide **}
		\Sinon {
			se déclarer comme inactif\;
			\Si{tous le monde est inactif} {
				déclencher \eventM
			}
			\tcp{** boucler sur la queue tant qu'on a rien à faire et que le travail
				n'est pas fini **}
			\Tq{\runnn \textbf{et} \nodes n'est pas défini}{
				essayer de récupérer un élément (sur \nodes) de la \queue\;
				\Si{\nodes n'est pas défini \textbf{\eventM} est déclenché}{
					valider l'événement de fin (var commune, non synchro)\;
					attendre la validation de tous ou la réinitialisation\;
					\lSi{tous le monde valide}{
						notifier \obj
					}\;
					\lSinon{
						continuer sur la boucle
					}
			}	}
			se déclarer comme actif\;	 
		}
		
		\tcp{** parcours de l'élément récupéré **}
		\PourCh{n \textbf{de} \nodes}{
			\tcp{* màj du résultat *}
			update(n, \obj, self)\;
			\tcp{* création d'un itérateur à envoyé dans la liste *}
			it $\la$ iter( \obj.\chd(n) )\;
			\tcp{* incrémentation de l'indice de synchronisation *}
			incrémenter($i$)\;
			\Si{$i$ = \ldots moment de se synchroniser \ldots} {
				$i \la 0$\;
				\queue reçoit it (si possible, modifier dans le cas d'une \queue ayant une
					taille maximale)\;
			} \lSinon{
				\liste reçoit it
		}	}
		
		\tcp{** regard sur la variable de validation de fin **}
		\Si{la variable de validation de l'événement est ``initialisé''}{
			désactiver l'événement\;
			réinitialiser la variable\;
		}
	}
\end{algorithm}

\begin{algorithm}[H]
	\caption{Update}
	\Donnees{
		$n$ : un noeud du parcours\\
	 	\obj : l'objet SearchForest2 qui contient les méthodes de résolutions\\
	 	self : l'objet qui est mis à jour}
	
	\BlankLine
	node $\la$ \obj.\pp($n$)\;
	\Si{node est défini}{
		self.res $\la$ \obj.\reduceF(self.res, node)
	}
\end{algorithm}

\end{document}